import global from '@/views/Global.vue'
let fire = {
    methods: {
        createParticleFire(options) {
            const viewer = global.viewer
            var entityFire = viewer.entities.add({
                position: options.position,
            });

            function computeModelMatrix(entity, time) {
                var position = Cesium.Property.getValueOrUndefined(entity.position);
                var modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(position);
                return modelMatrix;
            }

            function computeEmitterModelMatrix() {
                var hpr = Cesium.HeadingPitchRoll.fromDegrees(0, 0, 0);
                var trs = new Cesium.TranslationRotationScale();
                trs.translation = Cesium.Cartesian3.fromElements(2.5, 4, 1);
                trs.rotation = Cesium.Quaternion.fromHeadingPitchRoll(hpr);
                var result = Cesium.Matrix4.fromTranslationRotationScale(trs);
                return result;
            }

            var viewModel = {
                emissionRate: 5.0,
                gravity: 0.0,
                minimumParticleLife: 1.0,
                maximumParticleLife: 3.0,
                minimumSpeed: 1.0,
                maximumSpeed: 4.0,
                startScale: 1.0,
                endScale: 2.0,
                particleSize: 50.0,
                transX: 2.5,
                transY: 4.0,
                transZ: 1.0,
                heading: 0.0,
                pitch: 0.0,
                roll: 0.0,
                fly: true,
                spin: true,
                show: true
            };

            var primitive = viewer.scene.primitives.add(
                new Cesium.ParticleSystem({
                    image: options.image,
                    startColor: Cesium.Color.RED.withAlpha(0.7), //粒子出生时的颜色
                    endColor: Cesium.Color.YELLOW.withAlpha(0.3), //当粒子死亡时的颜色
                    startScale: viewModel.startScale, //粒子出生时的比例，相对于原始大小
                    endScale: viewModel.endScale, //粒子在死亡时的比例
                    minimumParticleLife: viewModel.minimumParticleLife, //设置粒子寿命的可能持续时间的最小界限（以秒为单位），粒子的实际寿命将随机生成
                    maximumParticleLife: viewModel.maximumParticleLife, //设置粒子寿命的可能持续时间的最大界限（以秒为单位），粒子的实际寿命将随机生成
                    minimumSpeed: viewModel.minimumSpeed, //设置以米/秒为单位的最小界限，超过该最小界限，随机选择粒子的实际速度。
                    maximumSpeed: viewModel.maximumSpeed, //设置以米/秒为单位的最大界限，超过该最大界限，随机选择粒子的实际速度。
                    imageSize: new Cesium.Cartesian2(viewModel.particleSize, viewModel.particleSize), //如果设置该属性，将会覆盖 minimumImageSize和maximumImageSize属性，以像素为单位缩放image的大小
                    emissionRate: viewModel.emissionRate, //每秒发射的粒子数。
                    bursts: [
                        // time：在粒子系统生命周期开始之后的几秒钟内将发生突发事件。
                        // minimum：突发中发射的最小粒子数量
                        // maximum：突发中发射的最大粒子数量
                        // new Cesium.ParticleBurst({ time: 5.0, minimum: 10, maximum: 100 }), // 当在5秒时，发射的数量为10-100
                        // new Cesium.ParticleBurst({ time: 10.0, minimum: 50, maximum: 100 }), // 当在10秒时，发射的数量为50-100
                        // new Cesium.ParticleBurst({ time: 15.0, minimum: 200, maximum: 300 }) // 当在15秒时，发射的数量为200-300
                    ],
                    lifetime: 16.0, //多长时间的粒子系统将以秒为单位发射粒子
                    emitter: new Cesium.ConeEmitter(Cesium.Math.toRadians(30.0)), //此系统的粒子发射器  共有 圆形、锥体、球体、长方体 ( BoxEmitter,CircleEmitter,ConeEmitter,SphereEmitter ) 几类
                    modelMatrix: computeModelMatrix(entityFire, Cesium.JulianDate.now()), // 4x4转换矩阵，可将粒子系统从模型转换为世界坐标
                    emitterModelMatrix: computeEmitterModelMatrix() // 4x4转换矩阵，用于在粒子系统本地坐标系中转换粒子系统发射器
                })
            );
            viewer.scene.primitives.add(primitive);
            // entityFire.remove = function() {
            //     viewer.entities.remove(entityFire);
            //     viewer.scene.primitives.remove(primitive);
            // };

            return entityFire;
        },
        /**
         * 
         * @param {*} skylineAnayStages  着色器
         * @param {boolean} silhouette 
         * @param {*} viewer 
         * @returns 
         */
        showSkylineAnay(skylineAnayStages, silhouette, viewer) {
            if (skylineAnayStages) {
                silhouette.enabled = true;
                return;
            }
            skylineAnayStages = viewer.scene.postProcessStages;
            let edgeDetection = Cesium.PostProcessStageLibrary.createEdgeDetectionStage();
            let postProccessStage = new Cesium.PostProcessStage({
                //此后处理阶段的唯一名称，供组合中其他阶段参考，如果未提供名称，将自动生成GUID
                // name:name,
                //unform着色器对象 textureScale
                fragmentShader: 'uniform sampler2D colorTexture;' +
                    'uniform sampler2D depthTexture;' +
                    'varying vec2 v_textureCoordinates;' +
                    'void main(void)' +
                    '{' +
                    'float depth = czm_readDepth(depthTexture, v_textureCoordinates);' +
                    'vec4 color = texture2D(colorTexture, v_textureCoordinates);' +
                    'if(depth<1.0 - 0.000001){' +
                    'gl_FragColor = color;' +
                    '}' +
                    'else{' +
                    'gl_FragColor = vec4(1.0,0.0,0.0,1.0);' +
                    '}' +
                    '}'
            });

            //PostProcessStage:要使用的片段着色器。默认sampler2D制服是colorTexture和depthTexture。
            let postProccesStage_1 = new Cesium.PostProcessStage({
                // name:obj.name+'_1',
                fragmentShader: 'uniform sampler2D colorTexture;' +
                    'uniform sampler2D redTexture;' +
                    'uniform sampler2D silhouetteTexture;' +
                    'varying vec2 v_textureCoordinates;' +
                    'void main(void)' +
                    '{' +
                    'vec4 redcolor=texture2D(redTexture, v_textureCoordinates);' +
                    'vec4 silhouetteColor = texture2D(silhouetteTexture, v_textureCoordinates);' +
                    'vec4 color = texture2D(colorTexture, v_textureCoordinates);' +
                    'if(redcolor.r == 1.0){' +
                    'gl_FragColor = mix(color, vec4(5.0,0.0,0.0,1.0), silhouetteColor.a);' +
                    '}' +
                    'else{' +
                    'gl_FragColor = color;' +
                    '}' +
                    '}',
                //uniform着色器对象
                uniforms: {
                    redTexture: postProccessStage.name,
                    silhouetteTexture: edgeDetection.name
                }
            });

            //如果inputPreviousStageTexture 是 true，则每个阶段输入是场景渲染到的输出纹理或之前执行阶段的输出纹理
            //如果inputPreviousStageTexture是false，则合成中每个阶段的输入纹理都是相同的
            silhouette = new Cesium.PostProcessStageComposite({
                //PostProcessStage要按顺序执行 的 s 或组合的数组。
                stages: [edgeDetection, postProccessStage, postProccesStage_1],
                //是否执行每个后处理阶段，其中一个阶段的输入是前一个阶段的输出。否则每个包含阶段的输入是组合之前执行的阶段的输出
                inputPreviousStageTexture: false,
                //后处理阶段制服的别名
                uniforms: edgeDetection.uniforms
            })
            skylineAnayStages.add(silhouette);
            return silhouette
        }
    },
}
export default fire